package view.backing.formula;

import chemtools_logica.Beans.DetalleformulaBean;
import chemtools_logica.Beans.FormulaBean;
import chemtools_logica.Beans.InsumoBean;

import chemtools_logica.Beans.TipogastoBean;
import chemtools_logica.Beans.TipoinsumoBean;
import chemtools_logica.Beans.TipoproductoBean;

import chemtools_logica.LN.IR.LN_SFDetalleformulaRemote;
import chemtools_logica.LN.IR.LN_SFFormulaRemote;
import chemtools_logica.LN.IR.LN_SFInsumoRemote;
import chemtools_logica.LN.IR.LN_SFTipoinsumoRemote;

import chemtools_logica.LN.IR.LN_SFTipoproductoRemote;

import chemtools_logica.LN.IR.LN_SFTransformacionesRemote;

import java.util.ArrayList;
import java.util.Date;
import java.util.Hashtable;


import java.util.List;

import javax.annotation.PostConstruct;

import javax.faces.event.AbortProcessingException;
import javax.faces.event.ActionEvent;

import javax.faces.model.SelectItem;

import javax.naming.Context;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import oracle.adf.view.rich.component.rich.RichForm;
import oracle.adf.view.rich.component.rich.RichPopup;
import oracle.adf.view.rich.component.rich.data.RichTable;

import oracle.adf.view.rich.component.rich.input.RichInputText;
import oracle.adf.view.rich.component.rich.input.RichSelectOneChoice;
import oracle.adf.view.rich.component.rich.layout.RichPanelFormLayout;

import oracle.adf.view.rich.component.rich.layout.RichPanelGridLayout;
import oracle.adf.view.rich.component.rich.layout.RichPanelGroupLayout;
import oracle.adf.view.rich.component.rich.nav.RichButton;
import oracle.adf.view.rich.event.PopupCanceledEvent;

import oracle.adf.view.rich.event.PopupFetchEvent;

import org.apache.myfaces.trinidad.event.SelectionEvent;

import view.backing.Utils.Utils;
import view.backing.insumos.Frm_insumos;

public class Frm_formula {

    private LN_SFFormulaRemote lN_SFFormulaRemote;
    private LN_SFDetalleformulaRemote lN_SFDetalleformulaRemote;
    private LN_SFTipoproductoRemote lN_SFTipoproductoRemote;
    private LN_SFTipoinsumoRemote lN_SFTipoinsumoRemote;
    private LN_SFTransformacionesRemote lN_SFTransformacionesRemote;

    private bSessionScopeBeanformula sessionScopeBeanformula = new bSessionScopeBeanformula();

    private RichTable tablaInsumos;
    private RichTable tablaFormulas;
    private RichForm formFormula;
    private RichPopup popRegistrar;
    private RichPanelFormLayout panelFormLayout1;
    private RichInputText it1;
    private RichPopup popupSeleccionarInsumo;
    private RichTable t_seleccionarInsumo;
    private RichPanelGroupLayout panelCamposNuevaFormula;
    private RichSelectOneChoice choiceSelectProducto;
    private RichSelectOneChoice choiceSelectInsumo;
    private RichTable editTablaInsumos;
    private RichPopup popEditar;
    private RichPanelGroupLayout panelCamposEditar;
    private RichSelectOneChoice editSelecProducto;
    private RichSelectOneChoice editSelecInsumo;
    private RichPanelGridLayout panelGridLayout1;
    private RichButton btnEditar;

    public Frm_formula() {
        super();
    }

    @PostConstruct
    public void methodInvokeOncedOnPageLoad() {
        try {
            final Context context = getInitialContext();
            lN_SFFormulaRemote =
                (LN_SFFormulaRemote) context.lookup("map-LN_SFFormula#chemtools_logica.LN.IR.LN_SFFormulaRemote");
            lN_SFDetalleformulaRemote =
                (LN_SFDetalleformulaRemote) context.lookup("map-LN_SFDetalleformula#chemtools_logica.LN.IR.LN_SFDetalleformulaRemote");
            lN_SFTipoproductoRemote =
                (LN_SFTipoproductoRemote) context.lookup("map-LN_SFTipoproducto#chemtools_logica.LN.IR.LN_SFTipoproductoRemote");
            lN_SFTipoinsumoRemote =
                (LN_SFTipoinsumoRemote) context.lookup("map-LN_SFTipoinsumo#chemtools_logica.LN.IR.LN_SFTipoinsumoRemote");
            lN_SFTransformacionesRemote =
                (LN_SFTransformacionesRemote) context.lookup("map-LN_SFTransformaciones#chemtools_logica.LN.IR.LN_SFTransformacionesRemote");
        } catch (Exception x) {System.out.print(x);
        }

        if (sessionScopeBeanformula.isExec()) {
            sessionScopeBeanformula.setListaFormula(lN_SFFormulaRemote.getAllFormulas());
            sessionScopeBeanformula.getBuscaFormulaBean().setEstado(-1);
        }
        sessionScopeBeanformula.setExec(false);
    }

    public void setSessionScopeBeanformula(bSessionScopeBeanformula sessionScopeBeanformula) {
        this.sessionScopeBeanformula = sessionScopeBeanformula;
    }

    public bSessionScopeBeanformula getSessionScopeBeanformula() {
        return sessionScopeBeanformula;
    }

    @SuppressWarnings("unchecked")
    private static Context getInitialContext() throws NamingException {
        Hashtable env = new Hashtable();
        // WebLogic Server 10.x/12.x connection details
        env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
        env.put(Context.PROVIDER_URL, "t3://127.0.0.1:7101");
        return new InitialContext(env);
    }

    public void seleccionarFormula(SelectionEvent se) {
        RichTable t = (RichTable) se.getSource();
        sessionScopeBeanformula.setFormulaSeleccionada((FormulaBean) t.getSelectedRowData());
        getBtnEditar().setDisabled(false);
        Utils.addTarget(getBtnEditar());
        
    }


    public void buscarFormulas(ActionEvent actionEvent) {

        sessionScopeBeanformula.setListaFormula(null);
        sessionScopeBeanformula.setListaFormula(lN_SFFormulaRemote.buscaFormulas(sessionScopeBeanformula.getBuscaFormulaBean()));
        getTablaFormulas().setValue(sessionScopeBeanformula.getListaFormula());
        Utils.addTarget(getTablaFormulas());

    }

    public void popupRegistrar(ActionEvent actionEvent) {
        sessionScopeBeanformula.setNuevaFormulaBean(new FormulaBean());
        sessionScopeBeanformula.setNuevaDetalleFormulaBean(new DetalleformulaBean());

        sessionScopeBeanformula.setListaProductoActivos(new ArrayList<TipoproductoBean>());

        sessionScopeBeanformula.setListaProductoActivos(lN_SFTipoproductoRemote.listaTipoProductoSinFormula());
        sessionScopeBeanformula.setProductoItems(new ArrayList<SelectItem>());
        sessionScopeBeanformula.getProductoItems().add(new SelectItem(-1, "Selecciona"));
        for (TipoproductoBean bean : sessionScopeBeanformula.getListaProductoActivos()) {
            sessionScopeBeanformula.getProductoItems().add(new SelectItem(bean.getIdTipoProducto(),
                                                                          bean.getDescripcion()));
        }

        sessionScopeBeanformula.setListaInsumosActivos(new ArrayList<TipoinsumoBean>());
        sessionScopeBeanformula.setListaInsumosActivos(lN_SFTipoinsumoRemote.getAlltipoInsumos());
        sessionScopeBeanformula.setListaItemTipoInsumo(new ArrayList<SelectItem>());
        sessionScopeBeanformula.getListaItemTipoInsumo().add(new SelectItem("-1", "Selecciona"));
        sessionScopeBeanformula.setItemInsumoSeleccionado(new SelectItem("-1", "Selecciona"));
        for (TipoinsumoBean bean : sessionScopeBeanformula.getListaInsumosActivos()) {
            sessionScopeBeanformula.getListaItemTipoInsumo().add(new SelectItem(bean.getIdTipoInsumo(),
                                                                                bean.getDescripcion()));
        }
        sessionScopeBeanformula.setIdProductoSeleccionado(-1);
        getBtnEditar().setDisabled(true);
        Utils.addTarget(getBtnEditar());
        Utils.showPopUpMIDDLE(getPopRegistrar());

    }

    public void limpiarCamposFormula(ActionEvent actionEvent) {
        sessionScopeBeanformula.setBuscaFormulaBean(new FormulaBean());
        sessionScopeBeanformula.getBuscaFormulaBean().setEstado(-1);
        sessionScopeBeanformula.setListaFormula(lN_SFFormulaRemote.getAllFormulas());
        getTablaFormulas().setValue(sessionScopeBeanformula.getListaFormula());
        getBtnEditar().setDisabled(true);
        Utils.clearRowSelection(getTablaFormulas());
        Utils.addTarget(getBtnEditar());
        Utils.addTarget(getPanelGridLayout1());
        Utils.addTarget(getTablaFormulas());
    }

    public void cancelRegistrar(ActionEvent actionEvent) {
        sessionScopeBeanformula.setProductoItems(new ArrayList<SelectItem>());
        sessionScopeBeanformula.setListaInsumosSelecionados(new ArrayList<TipoinsumoBean>());
        sessionScopeBeanformula.setQuitarInsumo(new TipoinsumoBean());
        getT_seleccionarInsumo().setValue(sessionScopeBeanformula.getListaInsumosSelecionados());
        Utils.addTarget(getT_seleccionarInsumo());
        limpiarCamposRegistrar();
        getPopRegistrar().hide();
        System.out.print("HOLA QUE HACE CANCELAR");
    }

    public void limpiarCamposRegistrar() {
        sessionScopeBeanformula.setCantidadInsumoString("");
        //sessionScopeBeanformula.setCantidadProductoString("");
        sessionScopeBeanformula.setNuevaFormulaBean(new FormulaBean());
    }

    public void aceptarRegistrar(ActionEvent actionEvent) {
        System.out.print("HOLA QUE HACE ACEPTAR");
        if (sessionScopeBeanformula.getNuevaFormulaBean().getNombre_Creador() == null) {
            Utils.showMessage("Debes Ingresar el nombre del creador", null, 2);
            return;
        }
        if (sessionScopeBeanformula.getNuevaFormulaBean().getApellido_Creador() == null) {
            Utils.showMessage("Debes Ingresar el Apellido del creador", null, 2);
            return;
        }
        if (existDescripcion(sessionScopeBeanformula.getNuevaFormulaBean().getDescripcion()) > 0) {
            Utils.showMessage("La descripcion ya existe por favor ingresa otra", null, 2);
            return;
        }
        /* SE DESABILITO EL CAMPO CANTIDAD PRODUCTO
        if (Integer.parseInt(sessionScopeBeanformula.getCantidadProductoString())  <= 0) {
            Utils.showMessage("Debes poner una camtidad de producto mayor a 0", null, 2);
            return;
        }
        */
        if (sessionScopeBeanformula.getIdProductoSeleccionado() <= 0) {
            Utils.showMessage("Falta seleccionar un Producto", null, 2);
            return;
        }


        if (sessionScopeBeanformula.getListaInsumosSelecionados().size() == 0) {
            Utils.showMessage("Debes tener por lo menos un insumo seleccionado", null, 2);
            return;
        }
        sessionScopeBeanformula.getProductoSeleccionado().setIdTipoProducto(sessionScopeBeanformula.getIdProductoSeleccionado());

        sessionScopeBeanformula.getNuevaDetalleFormulaBean().setTipoproducto(sessionScopeBeanformula.getProductoSeleccionado());

        sessionScopeBeanformula.getNuevaDetalleFormulaBean().setCantidad_Producto(1);

        /*
            int id = 0;
            boolean b = true;
            while (b) {
                id = (int) Math.floor(Math.random() * (1 - 100000) + 100000);
                if (existidFormula(id + "") == 0) {
                    b = false;
                }
            }

            sessionScopeBeanformula.getNuevaFormulaBean().setIdFormula(id);
            */
        FormulaBean formulabean = new FormulaBean();
        formulabean = sessionScopeBeanformula.getNuevaFormulaBean();
        formulabean.setEstado(1);
        formulabean.setFecha_Creacion(new Date());

        //insertar formula retornar el ID
        int id = lN_SFFormulaRemote.registraFormula(formulabean);
        formulabean = new FormulaBean();
        formulabean.setIdFormula(id);
        for (TipoinsumoBean tipoInsumo : sessionScopeBeanformula.getListaInsumosSelecionados()) {
            sessionScopeBeanformula.getNuevaDetalleFormulaBean().setCantidad_Insumo(Integer.parseInt(tipoInsumo.getCantidadInsumo()));
            sessionScopeBeanformula.getNuevaDetalleFormulaBean().setTipoinsumo(tipoInsumo);
            sessionScopeBeanformula.getNuevaDetalleFormulaBean().setFormula(formulabean);
            lN_SFDetalleformulaRemote.registrarDetalleFormula(sessionScopeBeanformula.getNuevaDetalleFormulaBean());
        }
        
        Utils.showMessage("Se Registro la formula correctamente", null, 2);
        buscarFormulas(actionEvent);
        cancelRegistrar(actionEvent);
    }


    public void agregarInsumo(ActionEvent actionEvent) {
        System.out.print("HOLA QUE HACE AGREGANDO INSUMO");
        TipoinsumoBean bean = new TipoinsumoBean();

        if (sessionScopeBeanformula.getCantidadInsumoString() == null) {
            Utils.showMessage("Debes Ingresar una cantidad de insumo", null, 2);
            return;
        }
        try {
            if (Integer.parseInt(sessionScopeBeanformula.getCantidadInsumoString()) <= 0) {
                Utils.showMessage("Debes poner una camtidad de insumo mayor a 0", null, 2);
                return;
            }
        } catch (NumberFormatException e) {
            Utils.showMessage("La cantidad de insumo debe ser numerico", null, 2);
            return;
        }
        if (sessionScopeBeanformula.getItemInsumoSeleccionado().getValue().equals("-1")) {
            Utils.showMessage("Debes seleccionar un Insumo", null, 1);
            return;
        }
        for (SelectItem item : sessionScopeBeanformula.getListaItemTipoInsumo()) {
            if (Integer.parseInt(item.getValue().toString()) ==
                Integer.parseInt(sessionScopeBeanformula.getItemInsumoSeleccionado().getValue().toString())) {
                bean.setIdTipoInsumo(Integer.parseInt(item.getValue().toString()));
                bean.setDescripcion(item.getLabel());
                bean.setCantidadProducto("1");
                bean.setCantidadInsumo(sessionScopeBeanformula.getCantidadInsumoString());
                bean.setMedida(lN_SFTipoinsumoRemote.getUnidadMedida(item.getValue().toString()));
                sessionScopeBeanformula.setInsumoSeleccionado(bean);
                sessionScopeBeanformula.getListaItemTipoInsumo().remove(item);
                break;
            }

        }

        sessionScopeBeanformula.getListaInsumosSelecionados().add(sessionScopeBeanformula.getInsumoSeleccionado());


        getT_seleccionarInsumo().setValue(sessionScopeBeanformula.getListaInsumosSelecionados());
        sessionScopeBeanformula.setCantidadInsumoString("");
        sessionScopeBeanformula.getItemInsumoSeleccionado().setValue("-1");
        Utils.addTarget(getPanelCamposNuevaFormula());
        Utils.addTarget(getChoiceSelectInsumo());
        Utils.addTarget(getT_seleccionarInsumo());

    }

    public void actionQuitarInsumo(ActionEvent actionEvent) {
        if (sessionScopeBeanformula.getQuitarInsumo() == null) {
            Utils.showMessage("Debes seleccionar un insumo de la tabla", null, 1);
            return;
        }
        if (sessionScopeBeanformula.getQuitarInsumo().getIdTipoInsumo() == 0) {
            Utils.showMessage("Debes seleccionar un insumo de la tabla", null, 1);
            return;
        }
        if (sessionScopeBeanformula.getListaInsumosSelecionados().size() == 0) {
            Utils.showMessage("Debes seleccionar un insumo de la tabla", null, 1);
            return;
        }
        sessionScopeBeanformula.getListaItemTipoInsumo().add(new SelectItem(sessionScopeBeanformula.getQuitarInsumo().getIdTipoInsumo(),
                                                                            sessionScopeBeanformula.getQuitarInsumo().getDescripcion()));

        sessionScopeBeanformula.getListaInsumosSelecionados().remove(sessionScopeBeanformula.getQuitarInsumo());
        sessionScopeBeanformula.setQuitarInsumo(null);
        Utils.addTarget(getT_seleccionarInsumo());
        Utils.addTarget(getChoiceSelectInsumo());
        Utils.clearRowSelection(getT_seleccionarInsumo());
    }

    public void quitaSelectInsumo(SelectionEvent selectionEvent) {
        RichTable t = (RichTable) selectionEvent.getSource();
        sessionScopeBeanformula.setQuitarInsumo((TipoinsumoBean) t.getSelectedRowData());
    }


    //POPUP EDITAR

    public void popupEditar(ActionEvent actionEvent) {

        int i = sessionScopeBeanformula.getFormulaSeleccionada().getIdFormula();
        sessionScopeBeanformula.setEditListaTipoInsumoSelecionados(new ArrayList<TipoinsumoBean>());
        if (i == 0) {
            Utils.showMessage("Debes seleccionar una Formula", null, 2);
            return;
        }
       
        //cargando datos de la formula
        FormulaBean fb=new FormulaBean();
        fb.setIdFormula(sessionScopeBeanformula.getFormulaSeleccionada().getIdFormula());
        fb.setDescripcion(sessionScopeBeanformula.getFormulaSeleccionada().getDescripcion());
        fb.setEstado(sessionScopeBeanformula.getFormulaSeleccionada().getEstado());
        fb.setFecha_Creacion(sessionScopeBeanformula.getFormulaSeleccionada().getFecha_Creacion());
        fb.setNombre_Creador(sessionScopeBeanformula.getFormulaSeleccionada().getNombre_Creador());
        fb.setApellido_Creador(sessionScopeBeanformula.getFormulaSeleccionada().getApellido_Creador());
        sessionScopeBeanformula.setEditFormulaBean(fb);

        //llenando el choice prooductos
        sessionScopeBeanformula.setEditListaItemTipoProducto(new ArrayList<SelectItem>());
        sessionScopeBeanformula.getEditListaItemTipoProducto().add(new SelectItem(-1, "Selecciona"));
        sessionScopeBeanformula.setListaProductoActivos(lN_SFTipoproductoRemote.listaTipoProductoSinFormula());
        int f = lN_SFDetalleformulaRemote.buscaxIdFormula(i).get(0).getTipoproducto().getIdTipoProducto();
        boolean b=true;
        for(TipoproductoBean tp : sessionScopeBeanformula.getListaProductoActivos()){
            if(tp.getIdTipoProducto()==f) {
                b=false;
                }
            }
        if(b){
        TipoproductoBean tpb = lN_SFTipoproductoRemote.buscaxIdTipoproducto(f);
        sessionScopeBeanformula.getListaProductoActivos().add(tpb);
        }
        for (TipoproductoBean bean : sessionScopeBeanformula.getListaProductoActivos()) {
            sessionScopeBeanformula.getEditListaItemTipoProducto().add(new SelectItem(bean.getIdTipoProducto(),
                                                                                      bean.getDescripcion()));
        }


        //cargando tabla de insumos seleccionados
        sessionScopeBeanformula.setEditListaDetalleFormula(lN_SFDetalleformulaRemote.buscaxIdFormula(i));
        for (DetalleformulaBean bean : sessionScopeBeanformula.getEditListaDetalleFormula()) {
            TipoinsumoBean tipoinsumo = new TipoinsumoBean();
            tipoinsumo.setIdTipoInsumo(bean.getTipoinsumo().getIdTipoInsumo());
            tipoinsumo.setDescripcion(bean.getTipoinsumo().getDescripcion());
            tipoinsumo.setCantidadInsumo(bean.getCantidad_Insumo() + "");
            tipoinsumo.setCantidadProducto("1");
            tipoinsumo.setMedida(lN_SFTipoinsumoRemote.getUnidadMedida(bean.getTipoinsumo().getIdTipoInsumo()+""));
            sessionScopeBeanformula.getEditListaTipoInsumoSelecionados().add(tipoinsumo);
            sessionScopeBeanformula.setIdTipoProductoSelec(bean.getTipoproducto().getIdTipoProducto() != 0 ?
                                                           bean.getTipoproducto().getIdTipoProducto() : -1);
            sessionScopeBeanformula.setTempIdTipoProductoSelec(bean.getTipoproducto().getIdTipoProducto());
        }

        //guardando la lista inicial de insumos seleccionados en una lista temporal
        for (TipoinsumoBean tib : sessionScopeBeanformula.getEditListaTipoInsumoSelecionados()) {
            sessionScopeBeanformula.getTempListaInsumosSelectec().add(tib);
        }


        //llenando el choice de insumos
        sessionScopeBeanformula.setEditListaItemTipoInsumo(new ArrayList<SelectItem>());
        sessionScopeBeanformula.getEditListaItemTipoInsumo().add(new SelectItem(-1, "Seleccionar"));
        sessionScopeBeanformula.setEditListaTipoInsumoNoSelecionados(lN_SFTipoinsumoRemote.getTipoinsumoNoSeleccionado(i));
        for (TipoinsumoBean bean : sessionScopeBeanformula.getEditListaTipoInsumoNoSelecionados()) {
            sessionScopeBeanformula.getEditListaItemTipoInsumo().add(new SelectItem(bean.getIdTipoInsumo(),
                                                                                    bean.getDescripcion()));
        }
        //

        if (sessionScopeBeanformula.isFirstEdit()) {
            getEditTablaInsumos().setValue(sessionScopeBeanformula.getEditListaTipoInsumoSelecionados());
        }
        sessionScopeBeanformula.setFirstEdit(true);
        sessionScopeBeanformula.setIdTipoInsumoSelec(-1);

        //System.out.print("HOLA QUE HACE intem "+sessionScopeBeanformula.getIdTipoProductoSelec());
        Utils.showPopUpMIDDLE(getPopEditar());
        Utils.clearRowSelection(getTablaFormulas());
    }

    public void editAgregarInsumo(ActionEvent actionEvent) {
        TipoinsumoBean bean = new TipoinsumoBean();
        //validaciones al agregar
        if (sessionScopeBeanformula.getEditCantidadInsumoString() == null) {
            Utils.showMessage("Debes Ingresar una cantidad de insumo", null, 2);
            return;
        }
        try {
            if (Integer.parseInt(sessionScopeBeanformula.getEditCantidadInsumoString()) <= 0) {
                Utils.showMessage("Debes poner una camtidad de insumo mayor a 0", null, 2);
                return;
            }
        } catch (NumberFormatException e) {
            Utils.showMessage("La cantidad de insumo debe ser numerico", null, 2);
            return;
        }
        if (sessionScopeBeanformula.getIdTipoInsumoSelec() == -1) {
            Utils.showMessage("Debes seleccionar un Insumo", null, 2);
            return;
        }
        if(formulaUsada(sessionScopeBeanformula.getFormulaSeleccionada().getIdFormula())){
                Utils.showMessage("No puedes agregar insumos a la formula porque ya se uso para una produccion", null, 2);
                return;
            }
        

        //copiar el insumo seleccionado y quitandolo del choice
        for (SelectItem item : sessionScopeBeanformula.getEditListaItemTipoInsumo()) {
            if (Integer.parseInt(item.getValue().toString()) == sessionScopeBeanformula.getIdTipoInsumoSelec()) {
                bean.setIdTipoInsumo(Integer.parseInt(item.getValue().toString()));
                bean.setDescripcion(item.getLabel());
                bean.setCantidadProducto("1");
                bean.setCantidadInsumo(sessionScopeBeanformula.getEditCantidadInsumoString());
                bean.setMedida(lN_SFTipoinsumoRemote.getUnidadMedida(item.getValue().toString()));
                sessionScopeBeanformula.setEditInsumoSeleccionado(bean);
                sessionScopeBeanformula.getEditListaItemTipoInsumo().remove(item);
                break;
            }
        }

        //cargando el insumo seleccionado al la lista de la tabla
        sessionScopeBeanformula.getEditListaTipoInsumoSelecionados().add(sessionScopeBeanformula.getEditInsumoSeleccionado());

        //cargando la nueva lista a la tabla
        getEditTablaInsumos().setValue(sessionScopeBeanformula.getEditListaTipoInsumoSelecionados());

        //poniendo en default el choice
        sessionScopeBeanformula.setIdTipoInsumoSelec(-1);
        sessionScopeBeanformula.setEditCantidadInsumoString("");
        //refrescando el choice , campo cantidad  y la tabla
        Utils.addTarget(getPanelCamposEditar());
        Utils.addTarget(getEditSelecInsumo());
        Utils.addTarget(getEditTablaInsumos());
    }

    public void editQuitaSelectInsumo(SelectionEvent selectionEvent) {
        RichTable t = (RichTable) selectionEvent.getSource();
        sessionScopeBeanformula.setEditQuitarInsumo((TipoinsumoBean) t.getSelectedRowData());
    }

    public void editActionQuitarInsumo(ActionEvent actionEvent) {
        //validaciones al quitar insumo

        if (sessionScopeBeanformula.getEditQuitarInsumo() == null) {
            Utils.showMessage("Debes seleccionar un insumo de la tabla", null, 1);
            System.out.println("ES NULO :::::::: ");
            return;
        }
        if (sessionScopeBeanformula.getEditQuitarInsumo().getIdTipoInsumo() == 0) {
            Utils.showMessage("Debes seleccionar un insumo de la tabla", null, 1);
            System.out.println("ES CERO :::::::: ");
            return;
        }
        if (sessionScopeBeanformula.getEditListaTipoInsumoSelecionados().size() == 0) {
            Utils.showMessage("No hay insumos en la tabla", null, 1);
            System.out.println("NO HAY INSUMOS :::::::: ");
            return;
        }
        if(formulaUsada(sessionScopeBeanformula.getFormulaSeleccionada().getIdFormula())){
                Utils.showMessage("No puedes Quitar insumos a la formula porque ya se uso para una produccion", null, 2);
                return;
            }
        sessionScopeBeanformula.getEditListaItemTipoInsumo().add(new SelectItem(sessionScopeBeanformula.getEditQuitarInsumo().getIdTipoInsumo(),
                                                                                sessionScopeBeanformula.getEditQuitarInsumo().getDescripcion()));

        for (TipoinsumoBean tib : sessionScopeBeanformula.getEditListaTipoInsumoSelecionados()) {
            if (tib.getIdTipoInsumo() == sessionScopeBeanformula.getEditQuitarInsumo().getIdTipoInsumo()) {
                sessionScopeBeanformula.getEditListaTipoInsumoSelecionados().remove(tib);
                break;
            }

        }

        getEditTablaInsumos().setValue(sessionScopeBeanformula.getEditListaTipoInsumoSelecionados());
        Utils.clearRowSelection(getEditTablaInsumos());
        Utils.addTarget(editTablaInsumos);
        Utils.addTarget(getEditSelecInsumo());

    }

    public void GuardarCambios(ActionEvent actionEvent) {

        if (sessionScopeBeanformula.getEditFormulaBean().getEstado() == -1) {
            Utils.showMessage("Debes seleccionar un Estado", null, 2);
            return;
        }
        
        if (tipoProductoTieneFormula(sessionScopeBeanformula.getIdTipoProductoSelec()) && sessionScopeBeanformula.getEditFormulaBean().getEstado() == 1) {
        if(sessionScopeBeanformula.getEditFormulaBean().getEstado()!=sessionScopeBeanformula.getFormulaSeleccionada().getEstado()){
            Utils.showMessage("El producto seleccionado ya tiene una Formula asignada", null, 2);
            return;
        }
        }
        if (sessionScopeBeanformula.getIdTipoProductoSelec() == -1) {
            Utils.showMessage("Debes seleccionar un producto", null, 2);
            return;
        }
        if (sessionScopeBeanformula.getEditListaTipoInsumoSelecionados().size() == 0) {
            Utils.showMessage("Debes tener por lo menos un insumo seleccionado", null, 2);
            return;
        }


        TipoproductoBean tp = new TipoproductoBean();
        FormulaBean formulabean = new FormulaBean();

        //borrando detalles de formula anterior
        formulabean.setIdFormula(sessionScopeBeanformula.getEditFormulaBean().getIdFormula());
        sessionScopeBeanformula.getEditDetalleFormulaBean().setFormula(formulabean);
        sessionScopeBeanformula.getEditDetalleFormulaBean().setCantidad_Producto(1);
        tp.setIdTipoProducto(sessionScopeBeanformula.getTempIdTipoProductoSelec());
        for (TipoinsumoBean tipoInsumo : sessionScopeBeanformula.getTempListaInsumosSelectec()) {
            sessionScopeBeanformula.getEditDetalleFormulaBean().setCantidad_Insumo(Integer.parseInt(tipoInsumo.getCantidadInsumo()));
            sessionScopeBeanformula.getEditDetalleFormulaBean().setTipoinsumo(tipoInsumo);
            sessionScopeBeanformula.getEditDetalleFormulaBean().setTipoproducto(tp);
            lN_SFDetalleformulaRemote.borraxIdFormula(sessionScopeBeanformula.getEditDetalleFormulaBean());
        }

        // modificando la formula anterior
        formulabean = sessionScopeBeanformula.getEditFormulaBean();
        lN_SFFormulaRemote.updateFormula(formulabean);


        //guardando la formula
        tp.setIdTipoProducto(sessionScopeBeanformula.getIdTipoProductoSelec());
        for (TipoinsumoBean tipoInsumo : sessionScopeBeanformula.getEditListaTipoInsumoSelecionados()) {
            sessionScopeBeanformula.getEditDetalleFormulaBean().setCantidad_Insumo(Integer.parseInt(tipoInsumo.getCantidadInsumo()));
            sessionScopeBeanformula.getEditDetalleFormulaBean().setTipoinsumo(tipoInsumo);
            sessionScopeBeanformula.getEditDetalleFormulaBean().setTipoproducto(tp);
            lN_SFDetalleformulaRemote.registrarDetalleFormula(sessionScopeBeanformula.getEditDetalleFormulaBean());
        }
        Utils.showMessage("Se guardaron los cambios exitosamente", null, 2);
        buscarFormulas(actionEvent);
        cancelarCambios(actionEvent);
    }

    public void cancelarCambios(ActionEvent actionEvent) {
        sessionScopeBeanformula.setEditFormulaBean(new FormulaBean());
        sessionScopeBeanformula.setIdTipoProductoSelec(-1);
        sessionScopeBeanformula.setEditListaItemTipoProducto(new ArrayList<SelectItem>());
        sessionScopeBeanformula.setEditCantidadInsumoString("");
        sessionScopeBeanformula.setIdTipoInsumoSelec(-1);
        sessionScopeBeanformula.setEditListaItemTipoInsumo(new ArrayList<SelectItem>());
        sessionScopeBeanformula.setEditListaTipoInsumoSelecionados(new ArrayList<TipoinsumoBean>());
        sessionScopeBeanformula.setEditInsumoSeleccionado(new TipoinsumoBean());
        sessionScopeBeanformula.setEditQuitarInsumo(new TipoinsumoBean());
        sessionScopeBeanformula.setEditDetalleFormulaBean(new DetalleformulaBean());
        sessionScopeBeanformula.setTempListaInsumosSelectec(new ArrayList<TipoinsumoBean>());
        //getEditTablaInsumos().setValue(sessionScopeBeanformula.getTempListaInsumosSelectec());
        Utils.addTarget(getEditTablaInsumos());
        Utils.clearRowSelection(getEditTablaInsumos());
        getPopEditar().hide();

    }
    //--fin popup Editar--

    //metodos de apoyo
    private boolean formulaUsada(int i) {
        return lN_SFFormulaRemote.formulaUsada(i);
    }
    
    private boolean tipoProductoTieneFormula(int idTipoProduco) {
        return lN_SFDetalleformulaRemote.productoTieneFormulaActiva(idTipoProduco);
    }

    private int existDescripcion(String string) {
        FormulaBean bean = new FormulaBean();
        int i = 0;

        bean.setDescripcion(sessionScopeBeanformula.getNuevaFormulaBean().getDescripcion());
        bean.setEstado(1);
        i = lN_SFFormulaRemote.buscaFormulas(bean).size();
        bean.setEstado(0);
        i += lN_SFFormulaRemote.buscaFormulas(bean).size();
        return i;
    }

    private int existidFormula(String string) {
        FormulaBean bean = new FormulaBean();
        int i = 0;
        bean.setIdFormula(Integer.parseInt(string));
        bean.setEstado(1);
        i = lN_SFFormulaRemote.buscaFormulas(bean).size();
        bean.setEstado(0);
        i += lN_SFFormulaRemote.buscaFormulas(bean).size();
        return i;
    }

    public void setPopRegistrar(RichPopup popRegistrar) {
        this.popRegistrar = popRegistrar;
    }

    public RichPopup getPopRegistrar() {
        return popRegistrar;
    }

    public void setPanelFormLayout1(RichPanelFormLayout panelFormLayout1) {
        this.panelFormLayout1 = panelFormLayout1;
    }

    public RichPanelFormLayout getPanelFormLayout1() {
        return panelFormLayout1;
    }

    public void setIt1(RichInputText it1) {
        this.it1 = it1;
    }

    public RichInputText getIt1() {
        return it1;
    }

    public void popupSeleccionarInsumo(ActionEvent actionEvent) {

        Utils.showPopUpMIDDLE(getPopupSeleccionarInsumo());
    }

    public void setPopupSeleccionarInsumo(RichPopup popupSeleccionarInsumo) {
        this.popupSeleccionarInsumo = popupSeleccionarInsumo;
    }

    public RichPopup getPopupSeleccionarInsumo() {
        return popupSeleccionarInsumo;
    }

    public void setT_seleccionarInsumo(RichTable t_seleccionarInsumo) {
        this.t_seleccionarInsumo = t_seleccionarInsumo;
    }

    public RichTable getT_seleccionarInsumo() {
        return t_seleccionarInsumo;
    }

    public void setTablaInsumos(RichTable tablaInsumos) {
        this.tablaInsumos = tablaInsumos;
    }

    public RichTable getTablaInsumos() {
        return tablaInsumos;
    }

    public void setTablaFormulas(RichTable tablaFormulas) {
        this.tablaFormulas = tablaFormulas;
    }

    public RichTable getTablaFormulas() {
        return tablaFormulas;
    }

    public void setFormFormula(RichForm formFormula) {
        this.formFormula = formFormula;
    }

    public RichForm getFormFormula() {
        return formFormula;
    }


    public void setPanelCamposNuevaFormula(RichPanelGroupLayout panelCamposNuevaFormula) {
        this.panelCamposNuevaFormula = panelCamposNuevaFormula;
    }

    public RichPanelGroupLayout getPanelCamposNuevaFormula() {
        return panelCamposNuevaFormula;
    }

    public void setChoiceSelectProducto(RichSelectOneChoice choiceSelectProducto) {
        this.choiceSelectProducto = choiceSelectProducto;
    }

    public RichSelectOneChoice getChoiceSelectProducto() {
        return choiceSelectProducto;
    }

    public void setChoiceSelectInsumo(RichSelectOneChoice choiceSelectInsumo) {
        this.choiceSelectInsumo = choiceSelectInsumo;
    }

    public RichSelectOneChoice getChoiceSelectInsumo() {
        return choiceSelectInsumo;
    }


    public void setEditTablaInsumos(RichTable editTablaInsumos) {
        this.editTablaInsumos = editTablaInsumos;
    }

    public RichTable getEditTablaInsumos() {
        return editTablaInsumos;
    }


    public void setPopEditar(RichPopup popEditar) {
        this.popEditar = popEditar;
    }

    public RichPopup getPopEditar() {
        return popEditar;
    }

    public void setPanelCamposEditar(RichPanelGroupLayout panelCamposEditar) {
        this.panelCamposEditar = panelCamposEditar;
    }

    public RichPanelGroupLayout getPanelCamposEditar() {
        return panelCamposEditar;
    }

    public void setEditSelecProducto(RichSelectOneChoice editSelecProducto) {
        this.editSelecProducto = editSelecProducto;
    }

    public RichSelectOneChoice getEditSelecProducto() {
        return editSelecProducto;
    }

    public void setEditSelecInsumo(RichSelectOneChoice editSelecInsumo) {
        this.editSelecInsumo = editSelecInsumo;
    }

    public RichSelectOneChoice getEditSelecInsumo() {
        return editSelecInsumo;
    }


    public void setPanelGridLayout1(RichPanelGridLayout panelGridLayout1) {
        this.panelGridLayout1 = panelGridLayout1;
    }

    public RichPanelGridLayout getPanelGridLayout1() {
        return panelGridLayout1;
    }


    public void setBtnEditar(RichButton btnEditar) {
        this.btnEditar = btnEditar;
    }

    public RichButton getBtnEditar() {
        return btnEditar;
    }
}
